I don't think this correctly handles the case that a is equal to b

ill add that case :)

took another look at the code... seems there are a few options

1. add an addition method to the Sortable interface Equals(T) bool and implement that on all types that have the Less Method implemented
2. take the slight performance hit of returning a -1, or 1 ... since returning 0 would just skip a swap operation. which is how it currently operates
3. We change the Less method to be similar to Compare and update that on all implementations

let me know if i might be missing some easier approach and if you have a preference on which i should move forward on

Can we use sort.Slice instead?

func Slice(x any, less func(i, j int) bool)

https://pkg.go.dev/sort#Slice

sort.Slice uses reflection and is slower than slices.SortFunc / slices.Sort

Personally, I like option 3 the best. Something like this seems reasonable:

type Sortable[T any] interface {
	Compare(T) int
}

looks like we will have to keep using the exp pkg here... i thought that the slices update was in 1.20. looks like its in 1.21. I will update that and just move forward with option 3

I had originally thought we would just do:

if a.Less(b) {
	return -1
}
if b.Less(a) {
	return 1
}
return 0

But changing the Sortable interface is a better long term strategy imo.

As for the go version change - we likely won't update to 1.21 until 1.22 is released

It is trivial to implement sort.Interface:

type sortables[T Sortable[T]] []T

func (s *sortables[T]) Len() int           { return len(*s) }
func (s *sortables[T]) Less(i, j int) bool { return (*s)[i].Less((*s)[j]) }
func (s *sortables[T]) Swap(i, j int)      { (*s)[i], (*s)[j] = (*s)[j], (*s)[i] }

Then you can just cast and call: sort.Sort(sortables(s))